import java.util.concurrent.*;

// 1. 实现 Callable 接口：计算 1~n 的累加和，返回 Integer 类型结果
class SumCallable implements Callable<Integer> {
    private final int n;

    public SumCallable(int n) {
        this.n = n;
    }

    // 2. 重写 call() 方法：有返回值，可抛出异常
    @Override
    public Integer call() throws IllegalArgumentException {
        if (n < 1) {
            // 直接抛出异常，无需内部捕获（调用者处理）
            throw new IllegalArgumentException("n 必须大于 0");
        }
        // 计算 1~n 的累加和，直接返回结果
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return sum;
    }
}

// 测试 Callable 任务
public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建 Callable 任务（计算 1~100 的和）
        SumCallable sumTask = new SumCallable(100);

        // 方式1：用 FutureTask 包装（配合 Thread 执行）
        FutureTask<Integer> futureTask = new FutureTask<>(sumTask);
        new Thread(futureTask).start();
        // 通过 FutureTask 获取结果（若任务未完成，get() 会阻塞直到结果返回）
        Integer result1 = futureTask.get();
        System.out.println("Callable 计算结果（FutureTask）：" + result1); // 输出 5050

        // 方式2：用线程池执行（返回 Future<Integer>）
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<Integer> future = executor.submit(sumTask); // 提交任务，返回 Future
        executor.shutdown();
        // 通过 Future 获取结果（可处理异常）
        try {
            Integer result2 = future.get(); // 阻塞获取结果
            System.out.println("Callable 计算结果（线程池）：" + result2); // 输出 5050
        } catch (ExecutionException e) {
            // 捕获 call() 方法抛出的异常
            System.out.println("任务执行异常：" + e.getCause().getMessage());
        }
    }
}